package MyString;

import java.util.Stack;

/**
 * 856. 括号的分数
 *
 * 给定一个平衡括号字符串 S，按下述规则计算该字符串的分数：
 *
 *     () 得 1 分。
 *     AB 得 A + B 分，其中 A 和 B 是平衡括号字符串。
 *     (A) 得 2 * A 分，其中 A 是平衡括号字符串。
 */
public class Leetcode0856_no {
    public static int scoreOfParentheses2(String S) {
        // 替换掉所有的（） 为 1
        String ss = S.replaceAll("\\(\\)", "1");
        System.out.println(ss);
        Stack<String> stack=new Stack();
        int tmp=0, flag =-1; // 0 左括号 1 数字 2 右括号
        for(int i=0; i<ss.length(); i++){
            char s_tmp = ss.charAt(i);
            // 左括号直接进栈
            if(s_tmp == '(') {
                stack.push(s_tmp +"");
                flag = 0;
            }else if(Character.isDigit(s_tmp) && flag != 1){
                // 数字直接进栈 栈顶不是数字的情况
                stack.push(s_tmp +"");
                flag = 1;
            }
            else if(Character.isDigit(s_tmp) && flag == 1){
                // 栈顶是数字的情况 数字与栈顶数字进行合并 +
                String top = stack.peek();
                stack.pop();
                int top_1 = Integer.valueOf(top);
                stack.push(String.valueOf(s_tmp - '0' + top_1));
                flag = 1;
            }else {
                // 栈顶是括号的情况 比如
                // 情况1: 栈（1     来了 ）
                // 情况2: 栈 （1（1 来了）
                // 情况3: 栈 （11   来了) 这种情况不会出现
                // 情况4: 栈 （     来了) 这种情况不会出现
                String top = stack.peek();
                int top_1 = Integer.valueOf(top);

                // 弹出数字和左括号
                stack.pop();
                stack.pop();
                if(stack.isEmpty() || stack.peek().equals("(")){
                    stack.push(String.valueOf(2 * top_1));
                    flag = 1;
                }else{
                    int tmp_2 = Integer.valueOf(stack.peek());
                    stack.pop();
                    stack.push(String.valueOf(tmp_2 + 2 * top_1));
                    flag = 1;
                }
            }
        }

        return Integer.valueOf(stack.peek());
    }

    // 使用 -1 代替 左括号
    public static int scoreOfParentheses(String S) {
        // 替换掉所有的（） 为 1
        String ss = S.replaceAll("\\(\\)", "1");
        System.out.println(ss);
        Stack<Integer> stack=new Stack();
        int flag =-1; // 0 左括号 1 数字 2 右括号 flag记录栈顶元素
        for(int i=0; i<ss.length(); i++){
            char s_tmp = ss.charAt(i);
            System.out.println(s_tmp);
            // 左括号直接进栈
            if(s_tmp == '(') {
                stack.push(-1);
                flag = 0;
            }else if(Character.isDigit(s_tmp) && flag != 1){
                // 数字直接进栈 栈顶不是数字的情况
                stack.push(s_tmp - '0');
                flag = 1;
            }
            else if(Character.isDigit(s_tmp) && flag == 1){
                // 栈顶是数字的情况 数字与栈顶数字进行合并 +
                int top_1 = stack.peek();
                stack.pop();
                stack.push(s_tmp - '0' + top_1);
                flag = 1;
            }else {
                // 栈顶是括号的情况 比如
                // 情况0: 栈（（1     来了 ）
                // 情况1: 栈（1     来了 ）
                // 情况2: 栈 （1（1 来了）
                // 情况3: 栈 （11   来了) 这种情况不会出现
                // 情况4: 栈 （     来了) 这种情况不会出现
                int top_1 = stack.peek();
                System.out.println(top_1);
                // 弹出数字和左括号
                stack.pop();
                stack.pop();
                if(stack.isEmpty() || stack.peek() == -1){
                    stack.push(2 * top_1);
                    flag = 1;
                }else{
                    int top_3 = stack.peek();
                    stack.pop();
                    stack.push(top_3 + 2 * top_1);
                    flag = 1;
                }
            }
        }

        return stack.peek();
    }

    public static void main(String[] args) {
        String ss = "((())())";
        System.out.println(scoreOfParentheses(ss));
    }
}
